home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Just Call Me Internet
/
Just Call Me Internet.iso
/
prog
/
atari
/
m2
/
cat3src
/
cat
/
windials.i
< prev
next >
Wrap
Text File
|
1997-10-26
|
24KB
|
803 lines
IMPLEMENTATION MODULE WinDials;
(*$Z+*)
(*$H+*)
FROM SYSTEM IMPORT ADDRESS, CAST, ADR, LOC, CALLSYS, CADR;
FROM Storage IMPORT ALLOCATE, DEALLOCATE;
IMPORT Strings;
IMPORT MagicAES, MagicVDI, mtDials, mtUtils, mtAppl, MagicStrings;
IMPORT GrafBase;
IMPORT WdwManager, MagicDOS;
IMPORT BinOps;
FROM Void IMPORT v;
TYPE
PtrWinDial = POINTER TO WinDial;
WinDial = RECORD
tree : ADDRESS;
wdw : INTEGER;
hdlSet : wdSetProc;
hdlGet : wdSetProc;
hdlBut : wdButtonProc;
hdlDraw : wdDrawProc;
private : ADDRESS;
modal : BOOLEAN;
docpos : GrafBase.Rectangle;
oldFrame: CHAR;
titleObj: INTEGER;
wasOutl : BOOLEAN;
editable: BOOLEAN;
cursorDa: BOOLEAN;
pos,
edit : INTEGER;
exit : INTEGER;
start,
depth : INTEGER; (* Fr Redraw von einzelnen Objekten *)
next,
prev : PtrWinDial;
END;
VAR dials : PtrWinDial;
dialExit : BOOLEAN;
dialReturn : INTEGER;
apName : Strings.String;
winAlerts : BOOLEAN;
originalDialDo: mtDials.DialDoProc;
(* Interface-Prozeduren zum WindowManager *)
PROCEDURE winDialDraw (wdw, vdi: INTEGER; special: ADDRESS; clip: GrafBase.Rectangle);
VAR dialPtr : PtrWinDial;
cr : GrafBase.Rectangle;
c2 : GrafBase.Rectangle;
cursorWarDa : BOOLEAN;
BEGIN
dialPtr := special;
WITH dialPtr^ DO
cr := clip;
mtUtils.AbsRect (cr);
cursorWarDa := cursorDa;
IF editable & (WdwManager.theTopWindow = wdw) & cursorDa
THEN
WdwManager.SetClip (mtAppl.PrivateWS, cr, FALSE);
mtDials.ObjcEdit (tree, edit, pos, 0, MagicAES.EDEND);
cursorDa := FALSE;
MagicVDI.SetClipping (mtAppl.PrivateWS, cr, FALSE);
END;
mtDials.DialDraw (tree, start, depth, clip, TRUE);
IF dialPtr^.hdlDraw # wdDrawProc (NIL)
THEN
dialPtr^.hdlDraw (tree, private, clip);
END;
IF editable & (WdwManager.theTopWindow = wdw) & ~cursorDa & cursorWarDa
THEN
WdwManager.SetClip (mtAppl.PrivateWS, cr, FALSE);
mtDials.ObjcEdit (tree, edit, pos, 0, MagicAES.EDINIT);
cursorDa := TRUE;
MagicVDI.SetClipping (mtAppl.PrivateWS, cr, FALSE);
END;
END;
END winDialDraw;
PROCEDURE winDialTop (wdw, vdi: INTEGER; special: ADDRESS): BOOLEAN;
VAR dialPtr : PtrWinDial;
BEGIN
dialPtr := special;
WITH dialPtr^ DO
IF editable & ~cursorDa & ~WdwManager.WindowIsShaded (wdw)
THEN
mtDials.ObjcEdit (tree, edit, pos, 0, MagicAES.EDINIT);
cursorDa := TRUE;
END;
END;
RETURN TRUE;
END winDialTop;
PROCEDURE winDialUntop (wdw, vdi: INTEGER; special: ADDRESS);
VAR dialPtr : PtrWinDial;
BEGIN
dialPtr := special;
WITH dialPtr^ DO
IF editable & cursorDa & ~WdwManager.WindowIsShaded (wdw)
THEN
mtDials.ObjcEdit (tree, edit, pos, 0, MagicAES.EDEND);
cursorDa := FALSE;
END;
END;
END winDialUntop;
PROCEDURE winDialHide (wdw, vdi: INTEGER; special: ADDRESS; hide: BOOLEAN);
VAR dialPtr : PtrWinDial;
BEGIN
(*
dialPtr := special;
WITH dialPtr^ DO
IF hide
THEN
winDialUntop (wdw, vdi, special);
ELSE
v.bool := winDialTop (wdw, vdi, special);
END;
END;
*)
END winDialHide;
PROCEDURE winDialGetArea (wdw, vdi: INTEGER; special: ADDRESS; VAR work: GrafBase.Rectangle);
VAR dialPtr : PtrWinDial;
obr : GrafBase.Rectangle;
BEGIN
dialPtr := special;
WITH dialPtr^ DO
(* Objectposition anpassen an neuen Workbereich *)
mtUtils.ObjcArea (tree, 0, obr);
obr.x := work.x - docpos.x;
obr.y := work.y - docpos.y;
mtUtils.SetObjcRect (tree, 0, obr);
END;
END winDialGetArea;
PROCEDURE winDialClose (wdw, vdi: INTEGER; special: ADDRESS; force: BOOLEAN): BOOLEAN;
VAR dialPtr : PtrWinDial;
BEGIN
dialPtr := special;
WITH dialPtr^ DO
hdlGet (tree, private, FALSE, exit);
(* dialogExit auf TRUE setzen *)
dialExit := TRUE;
(* Dialog freigeben *)
mtDials.DisposeDial (tree);
END;
(* Aus der Liste aushngen *)
IF dialPtr^.next # NIL
THEN
dialPtr^.next^.prev := dialPtr^.prev;
END;
IF dialPtr^.prev # NIL
THEN
dialPtr^.prev^.next := dialPtr^.next;
END;
IF dials = dialPtr
THEN
dials := dialPtr^.next;
END;
DISPOSE (dialPtr);
RETURN TRUE;
END winDialClose;
(* Interface-Prozeduren zum WindowManager: Objectbehandlung *)
PROCEDURE winDialButton (wdw, vdi: INTEGER; special: ADDRESS; mx, my : INTEGER;
kstate, buttons: BITSET; clicks: INTEGER): BOOLEAN;
VAR dialPtr : PtrWinDial;
exitDial: BOOLEAN;
entry : INTEGER;
scan,
taste : INTEGER;
char : CHAR;
BEGIN
dialPtr := special;
WITH dialPtr^ DO
IF wdw # WdwManager.theTopWindow THEN RETURN FALSE END;
IF WdwManager.WindowIsShaded (wdw) THEN RETURN FALSE END;
EXCL(buttons, MagicAES.MouseRight); (* rechte Taste brauchen wir nicht *)
entry := -1;
taste := 0;
scan := 0;
char := 0C;
IF mtDials.HandleEvent (BITSET{MagicAES.MUBUTTON}, mx, my,
buttons, taste, kstate, scan, char,
clicks, tree, editable, edit,
pos, entry)
THEN
IF clicks > 1
THEN
entry := INTEGER(BITSET(entry) + {15});
END;
exit := entry;
IF editable & cursorDa THEN mtDials.ObjcEdit (tree, edit, pos, 0, MagicAES.EDEND); cursorDa := FALSE; END;
exitDial := hdlBut (tree, private, entry, mx, my, kstate, clicks);
IF editable & ~cursorDa THEN mtDials.ObjcEdit (tree, edit, pos, 0, MagicAES.EDINIT); cursorDa := TRUE; END;
IF exitDial & editable
THEN
IF cursorDa THEN
mtDials.ObjcEdit (tree, edit, pos, 0, MagicAES.EDEND);
END;
cursorDa := FALSE;
END;
IF exitDial
THEN
CloseWinDial (tree);
END;
(* Exitbutton zurcksetzen *)
exit := -1;
(* An Windowmanager zurckgeben, da wir den behandelt haben *)
RETURN TRUE;
END;
END;
RETURN FALSE;
END winDialButton;
PROCEDURE winDialKey (wdw, vdi: INTEGER; special: ADDRESS; taste: INTEGER; key, scan: CHAR; kstate: BITSET): BOOLEAN;
VAR dialPtr : PtrWinDial;
exitDial: BOOLEAN;
entry : INTEGER;
mx, my : INTEGER;
clicks : INTEGER;
sc : INTEGER;
buts : BITSET;
BEGIN
dialPtr := special;
WITH dialPtr^ DO
IF wdw # WdwManager.theTopWindow THEN RETURN FALSE END;
IF WdwManager.WindowIsShaded (wdw) THEN RETURN FALSE END;
entry := -1;
buts := {};
clicks := 0; mx := 0; my := 0;
sc := ORD (scan);
IF mtDials.HandleEvent (BITSET{MagicAES.MUKEYBD}, mx, my,
buts, taste, kstate, sc, key,
clicks, tree, editable, edit,
pos, entry)
THEN
exit := entry;
IF editable & cursorDa THEN mtDials.ObjcEdit (tree, edit, pos, 0, MagicAES.EDEND); cursorDa := FALSE; END;
exitDial := hdlBut (tree, private, entry, mx, my, kstate, clicks);
IF editable & ~cursorDa THEN mtDials.ObjcEdit (tree, edit, pos, 0, MagicAES.EDINIT); cursorDa := TRUE; END;
IF exitDial & editable
THEN
IF cursorDa THEN mtDials.ObjcEdit (tree, edit, pos, 0, MagicAES.EDEND); END;
cursorDa := FALSE;
END;
IF exitDial
THEN
CloseWinDial (tree);
END;
(* Exitbutton zurcksetzen *)
exit := -1;
(* An Windowmanager zurckgeben, da wir den behandelt haben *)
RETURN TRUE;
ELSE
(* An Windowmanager zurckgeben, ob wir den behandelt haben.
* Wenn durch den Tastendruck nur ein Object selektiert wurde,
* dann wird entry auf diesen Eintrag gesetzt
*)
RETURN (entry > 0) OR modal;
END;
END;
RETURN FALSE;
END winDialKey;
PROCEDURE PrepareWinDial (wd: PtrWinDial; VAR work: GrafBase.Rectangle; VAR name: ARRAY OF CHAR);
(* Positioniert den Dialog und holt den Titel
*)
CONST CutHeight = 24; (* abzuschneidendes oberes Stck (Flyer und Titel) *)
VAR
extyp1,
extyp2,
typ : INTEGER;
obr,
docpos : GrafBase.Rectangle;
box : mtUtils.tObjcTree;
BEGIN
WITH wd^ DO
(* Outlined abschalten und Rand auf 1 Pixel setzen *)
wasOutl := mtUtils.InState (tree, 0, MagicAES.OUTLINED);
IF wasOutl
THEN
mtUtils.ExclState(tree, 0, MagicAES.OUTLINED);
box := tree;
oldFrame := box^[0].obSpec.Box.frame;
box^[0].obSpec.Box.frame := CAST(CHAR, -1);
END;
mtDials.DialCenter (tree, mtDials.CSCREEN, v.int, v.int, work);
mtUtils.ObjcArea (tree, 0, work);
docpos := work;
docpos.x := 0;
(* Haben wir einen Flyer und einen Titel?
* Dann sollten wir den oberen Rand abschneiden *)
mtDials.GetObjcExtype(tree, 1, extyp1, typ);
mtDials.GetObjcExtype(tree, 2, extyp2, typ);
IF (extyp1 = mtDials.MoveBox) AND (extyp2 = mtDials.SpecText)
OR (extyp2 = mtDials.MoveBox) AND (extyp1 = mtDials.SpecText)
THEN
(* oberen Rand abschneiden (Flyer und Titel) *)
docpos.y := (mtAppl.CharHeight * 2) ; (* CutHeight; *)
ELSE
(* Finger davon, solange kein Titel und Flyer da sind *)
docpos.y := 0;
END;
DEC (work.h, docpos.y); (* abgeschnittenen Rand von Flche abziehen *)
INC (work.y, docpos.y DIV 2); (* Nochmal zentrieren *)
(* Objectposition anpassen an neuen Workbereich *)
mtUtils.ObjcArea (tree, 0, obr);
obr.x := work.x - docpos.x;
obr.y := work.y - docpos.y;
mtUtils.SetObjcRect (tree, 0, obr);
IF extyp2 = mtDials.SpecText
THEN
mtUtils.ObjcString(tree, 2, name); (* Dialogtitel immer Objekt 2 *)
titleObj := 2;
ELSIF extyp1 = mtDials.SpecText
THEN
mtUtils.ObjcString(tree, 1, name); (* Dialogtitel immer Objekt 1 *)
titleObj := 1;
ELSE
MagicStrings.Assign ("", name); (* Kein Name, bergebenen Namen nehmen *)
END;
(* Leerzeichen abschneiden *)
Strings.DelTrailingBlanks (name);
Strings.DelLeadingBlanks (name);
IF (extyp1 = mtDials.MoveBox)
OR (extyp1 = mtDials.SpecText)
THEN
(* Objekte verstecken *)
mtUtils.InclFlag (tree, 1, MagicAES.HIDETREE);
IF ((extyp2 = mtDials.SpecText)
OR (extyp2 = mtDials.MoveBox))
& (extyp1 # extyp2)
THEN
mtUtils.InclFlag (tree, 2, MagicAES.HIDETREE);
END;
END;
END;
END PrepareWinDial;
PROCEDURE RestoreWinDial (wd: PtrWinDial);
VAR box : mtUtils.tObjcTree;
extyp1,
extyp2,
typ : INTEGER;
BEGIN
(* Setzt die Outline und den Rahmen wieder zurck *)
WITH wd^ DO
IF wasOutl
THEN
mtUtils.InclState (tree, 0, MagicAES.OUTLINED);
box := tree;
box^[0].obSpec.Box.frame := oldFrame;
END;
mtDials.GetObjcExtype(tree, 1, extyp1, typ);
mtDials.GetObjcExtype(tree, 2, extyp2, typ);
IF extyp1 = mtDials.MoveBox
THEN
(* Objekte nicht mehr verstecken *)
mtUtils.ExclFlag (tree, 1, MagicAES.HIDETREE);
IF extyp2 = mtDials.SpecText
THEN
mtUtils.ExclFlag (tree, 2, MagicAES.HIDETREE);
END;
END;
END;
END RestoreWinDial;
PROCEDURE FindWinDial (tree: ADDRESS): PtrWinDial;
VAR wdwPtr : PtrWinDial;
BEGIN
wdwPtr := dials;
WHILE (wdwPtr # NIL) & (wdwPtr^.tree # tree) DO wdwPtr := wdwPtr^.next END;
RETURN wdwPtr;
END FindWinDial;
PROCEDURE OpenWinDial (tr: ADDRESS;
isModal : BOOLEAN;
setValues: wdSetProc;
getValues: wdSetProc;
button : wdButtonProc;
draw : wdDrawProc;
REF title : ARRAY OF CHAR;
priv : ADDRESS): BOOLEAN;
(* Erzeugt einen Dialog im Fenster.
* Wenn der Dialog schon in einem Fenster ist, dann
* wird er getoppt.
* Ansonsten wird ein neues Fenster angelegt, setValues aufgerufen,
* um die Werte zu setzen, und dann wird das Fenster geffnet und
* angezeigt. Falls der Dialog modal ist, wird das Menu
* disablet.
* False: Fensterdialog konnte nicht angelegt werden
*)
VAR work : GrafBase.Rectangle;
wdwCurr: GrafBase.Rectangle;
obr : GrafBase.Rectangle;
comps : BITSET;
dialPtr : PtrWinDial;
name : ARRAY [0..79] OF CHAR;
BEGIN
(* Suchen, ob schon WinDial vorhanden *)
dialPtr := FindWinDial (tr);
IF dialPtr # NIL
THEN
WdwManager.TopWindow (dialPtr^.wdw);
RETURN TRUE;
END;
(* Noch nicht vorhanden, also neuen anlegen *)
NEW (dialPtr);
IF dialPtr = NIL
THEN
RETURN FALSE
END;
(* Neuen Dialog anlegen *)
IF ~mtDials.NewDial (tr)
THEN
DISPOSE (dialPtr);
RETURN FALSE;
END;
(* Fenster anlegen und ffnen *)
comps := BITSET{MagicAES.NAME, MagicAES.MOVE};
IF ~isModal
THEN
INCL(comps, MagicAES.CLOSER);
END;
IF ~WdwManager.CreateWindow (WdwManager.deskSize, work, comps,
"", "", dialPtr, TRUE, FALSE,
dialPtr^.wdw, v.int)
THEN
mtDials.DisposeDial (tr);
DISPOSE (dialPtr);
RETURN FALSE;
END;
IF ~WdwManager.SetWindowMode (dialPtr^.wdw, isModal)
THEN
mtDials.DisposeDial (tr);
DISPOSE (dialPtr);
RETURN FALSE;
END;
WITH dialPtr^ DO
tree := tr;
hdlSet := setValues;
hdlGet := getValues;
hdlBut := button;
hdlDraw:= draw;
modal := isModal;
private := priv;
depth := 99;
start := 0;
exit := -1;
titleObj := -1;
END;
(* Jetzt den Dialog vorbereiten, Titel und richtige Gre setzen
*)
PrepareWinDial (dialPtr, work, name);
IF name[0] = ''
THEN
MagicStrings.Assign (title, name);
Strings.DelTrailingBlanks (name);
END;
IF LENGTH(name) = 0
THEN
MagicStrings.Assign (apName, name);
END;
(* Jetzt die Windowspezifischen Sachen einhngen *)
WITH dialPtr^ DO
(* Ein kleiner Koordinatencheck *)
MagicAES.WindCalc (MagicAES.WCBORDER, comps, work, wdwCurr);
wdwCurr.y := BinOps.HigherInt (wdwCurr.y, WdwManager.deskSize.y);
MagicAES.WindCalc (MagicAES.WCWORK, comps, wdwCurr, work);
(* Objectposition anpassen an neuen Workbereich *)
mtUtils.ObjcArea (tree, 0, obr);
obr.x := work.x - docpos.x;
obr.y := work.y - docpos.y;
mtUtils.SetObjcRect (tree, 0, obr);
WdwManager.SetWdwWork (wdw, work);
WdwManager.SetWdwTitle (wdw, name);
v.bool := WdwManager.SetWindowButton (wdw, winDialButton);
v.bool := WdwManager.SetWindowKey (wdw, winDialKey);
v.bool := WdwManager.SetWindowDraw (wdw, winDialDraw);
v.bool := WdwManager.SetWindowTop (wdw, winDialTop);
v.bool := WdwManager.SetWindowUntop (wdw, winDialUntop);
v.bool := WdwManager.SetWindowClose (wdw, winDialClose);
v.bool := WdwManager.SetWindowHide (wdw, winDialHide);
v.bool := WdwManager.SetWindowDial (wdw, tree);
v.bool := WdwManager.SetWindowGetScroll (wdw, winDialGetArea);
END;
(* So, jetzt noch in Liste einhngen *)
dialPtr^.prev := NIL;
IF dials = NIL
THEN
dialPtr^.next := NIL;
ELSE
(* Am Anfang einhngen *)
dialPtr^.next := dials;
dials^.prev := dialPtr;
END;
dials := dialPtr;
(* Und jetzt zeigen wir das Fenster an *)
WITH dialPtr^ DO
mtDials.PrepDial (tree, 0, editable, pos, edit);
hdlSet (tree, private, TRUE, -1);
cursorDa := FALSE;
v.bool := WdwManager.ShowWindow (wdw);
END;
RETURN TRUE
END OpenWinDial;
PROCEDURE CloseWinDial (tree: ADDRESS);
(* schliet einen Fensterdialog. getValues wird aufgerufen.
*)
VAR dialPtr: PtrWinDial;
BEGIN
(* Suchen, ob schon WinDial vorhanden *)
dialPtr := FindWinDial (tree);
IF dialPtr # NIL
THEN
RestoreWinDial (dialPtr);
v.bool := WdwManager.CloseWindow (dialPtr^.wdw, FALSE);
END;
END CloseWinDial;
PROCEDURE FormHandle(form : ADDRESS; edit: INTEGER):INTEGER;
VAR exit : INTEGER;
BEGIN
IF ~mtDials.NewDial (form)
THEN
RETURN -1;
END;
MagicAES.WindUpdate (MagicAES.BEGUPDATE);
mtDials.DialCenter(form, mtDials.CSCREEN, 0,0, v.r);
mtDials.DialForm(form, mtDials.DSTART, v.r, v.r);
mtDials.DialDraw(form, 0,200, v.r, FALSE);
IF winAlerts
THEN
exit := originalDialDo(form, edit);
ELSE
exit := mtDials.DialDo (form, edit);
END;
exit := INTEGER(BITSET(exit) - {15});
mtDials.DialForm(form, mtDials.DFINISH, v.r, v.r);
mtUtils.ExclState(form, exit, MagicAES.SELECTED);
mtDials.DisposeDial (form);
MagicAES.WindUpdate (MagicAES.ENDUPDATE);
RETURN exit
END FormHandle;
PROCEDURE defDraw (tree, private: ADDRESS; clip: GrafBase.Rectangle);
END defDraw;
PROCEDURE defSet (tree, private: ADDRESS; set: BOOLEAN; exitBut: INTEGER);
END defSet;
PROCEDURE defButton (tree, private: ADDRESS; obj: INTEGER;
mx, my: INTEGER; kstate : BITSET;
clicks: INTEGER): BOOLEAN;
BEGIN
mtUtils.ExclState (tree, obj, MagicAES.SELECTED);
dialExit := TRUE;
dialReturn := obj;
RETURN TRUE;
END defButton;
PROCEDURE WinDialDraw (tree: ADDRESS; entry, dpth: INTEGER;
clip: ARRAY OF LOC; clipping: BOOLEAN);
VAR pr: POINTER TO GrafBase.Rectangle;
r : GrafBase.Rectangle;
dialPtr: PtrWinDial;
BEGIN
(* Suchen, ob schon WinDial vorhanden *)
dialPtr := FindWinDial (tree);
IF dialPtr # NIL
THEN
WITH dialPtr^ DO
depth := dpth;
start := entry;
IF clipping
THEN
pr := ADR (clip);
WdwManager.RedrawWdw (wdw, pr^)
ELSE
mtUtils.CalcArea (tree, entry, r);
WdwManager.RedrawWdw (wdw, r);
END;
depth := 99;
start := 0;
END;
ELSE
mtDials.DialDraw (tree, entry, dpth, clip, clipping);
END;
END WinDialDraw;
PROCEDURE WinDialHandleEvents ();
(* Durchluft die Eventloop, bis das Topwindow mit dem aktuellen Dialog
* geschlossen wird
*)
VAR Events : BITSET;
clicks,
taste,
mx, my : INTEGER;
buts,
kstate : BITSET;
event : BITSET;
mBuff : ARRAY [0..7] OF INTEGER;
scan : INTEGER;
sc,
key : CHAR;
BEGIN
dialExit := FALSE;
dialReturn := -1;
WdwManager.DisableMenu (NIL, TRUE);
Events := BITSET{MagicAES.MUKEYBD, MagicAES.MUBUTTON, MagicAES.MUMESAG};
MagicAES.WindUpdate (MagicAES.ENDUPDATE);
LOOP
event := MagicAES.EvntMulti(Events,
2, BITSET{MagicAES.MouseLeft},
BITSET{MagicAES.MouseLeft},
0, GrafBase.Rectangle{0,0,0,0},
0, GrafBase.Rectangle{0,0,0,0}, (* Mouse2Rect *)
mBuff,
0, 0, (* Timerdauer *)
mx, my, (* Maus-Position *)
buts, (* Maus-Buttons *)
taste, (* gedrckte Taste *)
kstate, (* Shift-state *)
scan, (* scan-code *)
key, (* ascii-code *)
clicks); (* Klick-Anzahl *)
sc := CHR(scan);
MagicAES.WindUpdate (MagicAES.BEGUPDATE);
v.bool := WdwManager.HandleEvent (event, mBuff, buts, kstate, key, sc,
taste, mx, my, clicks);
MagicAES.WindUpdate (MagicAES.ENDUPDATE);
IF dialExit THEN EXIT END;
END;
dialExit := FALSE;
MagicAES.WindUpdate (MagicAES.BEGUPDATE);
WdwManager.DisableMenu (NIL, FALSE);
END WinDialHandleEvents;
PROCEDURE WinDialDo (tree: ADDRESS; edit: INTEGER): INTEGER;
(* Fhrt einen kompletten modalen Fensterdialog durch. Es wird
* der Button zurckgegeben, mit dem der Dialog verlassen wurde.
* Wenn kein Fenster mehr frei ist, wird ein normaler Dialog gezeichnet
*)
BEGIN
IF ~OpenWinDial (tree, TRUE, defSet, defSet, defButton, defDraw, "", NIL)
THEN
(* normalen Dialog durchfhren *)
RETURN FormHandle (tree, edit);
END;
WinDialHandleEvents();
RETURN dialReturn;
END WinDialDo;
PROCEDURE WinDialIsTop (wdw: INTEGER): BOOLEAN;
(* Fragt nach, ob das Fenster wdw ein Fensterdialog ist
*)
VAR wdwPtr : PtrWinDial;
BEGIN
wdwPtr := dials;
WHILE (wdwPtr # NIL) & (wdwPtr^.wdw # wdw) DO wdwPtr := wdwPtr^.next END;
RETURN wdwPtr # NIL;
END WinDialIsTop;
PROCEDURE SetApplicationName (REF name : ARRAY OF CHAR);
BEGIN
MagicStrings.Assign (name, apName);
END SetApplicationName;
PROCEDURE WinEditChanged (tree: ADDRESS; newEdit: INTEGER);
(* Setzt den Cursor in ein neues Editfeld bzw. teilt dem Modul
* mit, da sich der Text gendert hat und da der Cursor neu plaziert
* werden soll. edit = -1: Nur Cursor neu plazieren.
*)
VAR dialPtr: PtrWinDial;
cursorWarDa: BOOLEAN;
BEGIN
(* Suchen, ob schon WinDial vorhanden *)
dialPtr := FindWinDial (tree);
IF dialPtr # NIL
THEN
WITH dialPtr^ DO
IF editable
THEN
cursorWarDa := cursorDa;
IF cursorDa
THEN
mtDials.ObjcEdit (tree, edit, pos, 0, MagicAES.EDEND);
cursorDa := FALSE;
END;
IF (newEdit >= 0)
THEN
edit := newEdit;
END;
pos := -1;
IF cursorWarDa
THEN
mtDials.ObjcEdit (tree, edit, pos, 0, MagicAES.EDINIT);
cursorDa := TRUE;
END;
END;
END;
END;
END WinEditChanged;
PROCEDURE WinUpdateTitle (tree: ADDRESS);
VAR dialPtr: PtrWinDial;
name : ARRAY [0..79] OF CHAR;
BEGIN
(* Suchen, ob schon WinDial vorhanden *)
dialPtr := FindWinDial (tree);
IF dialPtr # NIL
THEN
WITH dialPtr^ DO
IF titleObj >= 0
THEN
mtUtils.ObjcString(tree, titleObj, name); (* Dialogtitel immer Objekt 2 *)
Strings.DelTrailingBlanks (name);
Strings.DelLeadingBlanks (name);
WdwManager.SetWdwTitle (wdw, name);
END;
END;
END;
END WinUpdateTitle;
PROCEDURE IsWinDial (tree: ADDRESS): BOOLEAN;
(* Fragt nach, ob der Dialog schon in einem Fenster ist
*)
VAR dialPtr: PtrWinDial;
BEGIN
(* Suchen, ob schon WinDial vorhanden *)
dialPtr := FindWinDial (tree);
RETURN dialPtr # NIL;
END IsWinDial;
PROCEDURE ActivateWinDial (tree: ADDRESS);
(* Aktiviert den Window-Dialog, falls vorhanden
*)
VAR dialPtr: PtrWinDial;
BEGIN
(* Suchen, ob schon WinDial vorhanden *)
dialPtr := FindWinDial (tree);
IF dialPtr # NIL
THEN
WdwManager.TopWindow (dialPtr^.wdw);
END;
END ActivateWinDial;
PROCEDURE AlertsInWindow (doIt: BOOLEAN);
BEGIN
IF (doIt = TRUE) & (winAlerts = FALSE)
THEN
originalDialDo := mtDials.OverloadDialDo (WinDialDo);
winAlerts := TRUE;
ELSIF (doIt = FALSE) & (winAlerts = TRUE)
THEN
winAlerts := FALSE;
originalDialDo := mtDials.OverloadDialDo (mtDials.DialDoProc(NIL));
END;
END AlertsInWindow;
BEGIN
dials := NIL;
apName := "";
winAlerts := FALSE;
(*
originalDialDo := mtDials.OverloadDialDo (WinDialDo);
*)
END WinDials.